package parser

import (
	"fmt"
	"jsengine/ast"
	"jsengine/lexer"
	"strconv"
)

// 定义优先级
const (
	_ int = iota
	LOWEST
	ASSIGNS      // =
	CONDITIONALS // ? :
	LOGICAL      // || &&
	EQUALS       // == !=
	LESSGREATER  // > < >= <=
	SUM          // + -
	PRODUCT      // * / %
	PREFIX       // -X !X
	CALL         // myFunction(X)
	INDEX        // array[index]
	PROPERTY     // obj.property
)

// 优先级映射表
var precedences = map[lexer.TokenType]int{
	lexer.EQ:           EQUALS,
	lexer.NOT_EQ:       EQUALS,
	lexer.LT:           LESSGREATER,
	lexer.GT:           LESSGREATER,
	lexer.LTE:          LESSGREATER,
	lexer.GTE:          LESSGREATER,
	lexer.PLUS:         SUM,
	lexer.MINUS:        SUM,
	lexer.SLASH:        PRODUCT,
	lexer.ASTERISK:     PRODUCT,
	lexer.PERCENT:      PRODUCT,
	lexer.LPAREN:       CALL,
	lexer.LBRACKET:     INDEX,
	lexer.DOT:          PROPERTY,
	lexer.AND:          LOGICAL,
	lexer.OR:           LOGICAL,
	lexer.ASSIGN:       ASSIGNS,
	lexer.PLUS_ASSIGN:  ASSIGNS,
	lexer.MINUS_ASSIGN: ASSIGNS,
	lexer.MUL_ASSIGN:   ASSIGNS,
	lexer.DIV_ASSIGN:   ASSIGNS,
	lexer.MOD_ASSIGN:   ASSIGNS,
	lexer.INCREMENT:    PREFIX,
	lexer.DECREMENT:    PREFIX,
	lexer.QUESTION:     CONDITIONALS,
	lexer.ARROW:        LOWEST,
}

// 定义前缀解析函数和中缀解析函数的类型
type (
	prefixParseFn func() ast.Expression
	infixParseFn  func(ast.Expression) ast.Expression
)

// Parser 结构体表示语法分析器
type Parser struct {
	l          *lexer.Lexer
	errors     []string
	errorInfos []ErrorInfo

	curToken  lexer.Token
	peekToken lexer.Token

	prefixParseFns map[lexer.TokenType]prefixParseFn
	infixParseFns  map[lexer.TokenType]infixParseFn
}

// New 创建一个新的语法分析器
func New(l *lexer.Lexer) *Parser {
	p := &Parser{
		l:          l,
		errors:     []string{},
		errorInfos: []ErrorInfo{},
	}

	p.prefixParseFns = make(map[lexer.TokenType]prefixParseFn)
	p.infixParseFns = make(map[lexer.TokenType]infixParseFn)

	// 注册前缀表达式解析函数
	p.registerPrefix(lexer.IDENT, p.parseIdentifier)
	p.registerPrefix(lexer.INT, p.parseIntegerLiteral)
	p.registerPrefix(lexer.FLOAT, p.parseFloatLiteral)
	p.registerPrefix(lexer.STRING, p.parseStringLiteral)
	p.registerPrefix(lexer.TEMPLATE, p.parseTemplateLiteral)
	p.registerPrefix(lexer.BANG, p.parsePrefixExpression)
	p.registerPrefix(lexer.MINUS, p.parsePrefixExpression)
	p.registerPrefix(lexer.TRUE, p.parseBooleanLiteral)
	p.registerPrefix(lexer.FALSE, p.parseBooleanLiteral)
	p.registerPrefix(lexer.NULL, p.parseNullLiteral)
	p.registerPrefix(lexer.UNDEFINED, p.parseUndefinedLiteral)
	p.registerPrefix(lexer.LPAREN, p.parseGroupedExpression)
	p.registerPrefix(lexer.IF, p.parseIfExpression)
	p.registerPrefix(lexer.FUNCTION, p.parseFunctionLiteral)
	p.registerPrefix(lexer.LBRACKET, p.parseArrayLiteral)
	p.registerPrefix(lexer.LBRACE, p.parseObjectLiteral)
	p.registerPrefix(lexer.CLASS, p.parseClassExpression)
	p.registerPrefix(lexer.NEW, p.parseNewExpression)
	p.registerPrefix(lexer.THIS, p.parseThisExpression)
	p.registerPrefix(lexer.ARROW, p.parseArrowWithNoParam)
	p.registerPrefix(lexer.STATIC, p.parseStaticKeyword)
	p.registerPrefix(lexer.SUPER, p.parseSuperExpression)
	p.registerPrefix(lexer.SEMICOLON, p.parseSemicolonExpression)
	p.registerPrefix(lexer.INCREMENT, p.parsePrefixExpression)
	p.registerPrefix(lexer.DECREMENT, p.parsePrefixExpression)

	// 注册中缀表达式解析函数
	p.registerInfix(lexer.PLUS, p.parseInfixExpression)
	p.registerInfix(lexer.MINUS, p.parseInfixExpression)
	p.registerInfix(lexer.SLASH, p.parseInfixExpression)
	p.registerInfix(lexer.ASTERISK, p.parseInfixExpression)
	p.registerInfix(lexer.PERCENT, p.parseInfixExpression)
	p.registerInfix(lexer.EQ, p.parseInfixExpression)
	p.registerInfix(lexer.NOT_EQ, p.parseInfixExpression)
	p.registerInfix(lexer.LT, p.parseInfixExpression)
	p.registerInfix(lexer.GT, p.parseInfixExpression)
	p.registerInfix(lexer.LTE, p.parseInfixExpression)
	p.registerInfix(lexer.GTE, p.parseInfixExpression)
	p.registerInfix(lexer.LPAREN, p.parseCallExpression)
	p.registerInfix(lexer.LBRACKET, p.parseIndexExpression)
	p.registerInfix(lexer.DOT, p.parsePropertyExpression)
	p.registerInfix(lexer.ASSIGN, p.parseAssignExpression)
	p.registerInfix(lexer.AND, p.parseInfixExpression)
	p.registerInfix(lexer.OR, p.parseInfixExpression)
	p.registerInfix(lexer.QUESTION, p.parseConditionalExpression)
	p.registerInfix(lexer.INCREMENT, p.parsePostfixExpression)
	p.registerInfix(lexer.DECREMENT, p.parsePostfixExpression)
	p.registerInfix(lexer.PLUS_ASSIGN, p.parseCompoundAssignExpression)
	p.registerInfix(lexer.MINUS_ASSIGN, p.parseCompoundAssignExpression)
	p.registerInfix(lexer.MUL_ASSIGN, p.parseCompoundAssignExpression)
	p.registerInfix(lexer.DIV_ASSIGN, p.parseCompoundAssignExpression)
	p.registerInfix(lexer.MOD_ASSIGN, p.parseCompoundAssignExpression)

	// 特别强调箭头函数的解析
	p.registerInfix(lexer.ARROW, p.parseArrowFunctionWithSingleParam)

	// 读取两个token，设置curToken和peekToken
	p.nextToken()
	p.nextToken()

	return p
}

// nextToken 前进到下一个词法单元
func (p *Parser) nextToken() {
	p.curToken = p.peekToken
	p.peekToken = p.l.NextToken()
}

// Errors 返回解析过程中收集的错误
func (p *Parser) Errors() []string {
	return p.errors
}

// peekError 添加一个预期Token类型不匹配的错误
func (p *Parser) peekError(t lexer.TokenType) {
	msg := fmt.Sprintf("语法错误: 在第%d行第%d列, 期望下一个词法单元为 %s，得到的却是 %s",
		p.peekToken.Line, p.peekToken.Column, t, p.peekToken.Type)
	p.errors = append(p.errors, msg)
}

// registerPrefix 注册前缀解析函数
func (p *Parser) registerPrefix(tokenType lexer.TokenType, fn prefixParseFn) {
	p.prefixParseFns[tokenType] = fn
}

// registerInfix 注册中缀解析函数
func (p *Parser) registerInfix(tokenType lexer.TokenType, fn infixParseFn) {
	p.infixParseFns[tokenType] = fn
}

// ParseProgram 解析整个程序
func (p *Parser) ParseProgram() *ast.Program {
	program := &ast.Program{
		Statements: []ast.Statement{},
	}

	for p.curToken.Type != lexer.EOF {
		stmts := p.parseStatement()
		if stmts != nil {
			program.Statements = append(program.Statements, stmts...)
		}
		p.nextToken()
	}

	return program
}

// parseStatement 解析语句
func (p *Parser) parseStatement() []ast.Statement {
	switch p.curToken.Type {
	case lexer.LET:
		stmts := p.parseLetStatement()
		if stmts != nil {
			// 将[]*ast.LetStatement转换为[]ast.Statement
			result := make([]ast.Statement, len(stmts))
			for i, stmt := range stmts {
				result[i] = stmt
			}
			return result
		}
		return nil
	case lexer.VAR:
		stmts := p.parseVarStatement()
		if stmts != nil {
			// 将[]*ast.VarStatement转换为[]ast.Statement
			result := make([]ast.Statement, len(stmts))
			for i, stmt := range stmts {
				result[i] = stmt
			}
			return result
		}
		return nil
	case lexer.CONST:
		stmts := p.parseConstStatement()
		if stmts != nil {
			// 将[]*ast.ConstStatement转换为[]ast.Statement
			result := make([]ast.Statement, len(stmts))
			for i, stmt := range stmts {
				result[i] = stmt
			}
			return result
		}
		return nil
	case lexer.RETURN:
		stmt := p.parseReturnStatement()
		if stmt != nil {
			return []ast.Statement{stmt}
		}
		return nil
	case lexer.FUNCTION:
		stmt := p.parseFunctionStatement()
		if stmt != nil {
			return []ast.Statement{stmt}
		}
		return nil
	case lexer.IF:
		// 对于if/else语句，我们处理表达式语句
		stmt := &ast.ExpressionStatement{
			Token:      p.curToken,
			Expression: p.parseIfExpression(),
		}
		return []ast.Statement{stmt}
	case lexer.FOR:
		// 检查这是否是for...in或for...of循环
		// 保存当前位置，以便需要时回退
		curToken := p.curToken
		curPosition, curReadPosition, curCh := p.l.GetPosition()

		// 前看是否符合for...in或for...of模式: for (var i in obj) 或 for (i of arr)
		p.nextToken() // 跳过for
		if !p.curTokenIs(lexer.LPAREN) {
			// 回退并解析为普通for循环
			p.l.SetPosition(curPosition, curReadPosition, curCh)
			p.curToken = curToken
			stmt := p.parseForLoopStatement()
			return []ast.Statement{stmt}
		}

		p.nextToken() // 跳过左括号

		// 检查是否有var/let/const
		hasDeclaration := false
		if p.curTokenIs(lexer.VAR) || p.curTokenIs(lexer.LET) || p.curTokenIs(lexer.CONST) {
			hasDeclaration = true
			p.nextToken() // 跳过声明关键字
		}

		// 必须是标识符
		if !p.curTokenIs(lexer.IDENT) {
			// 回退并解析为普通for循环
			p.l.SetPosition(curPosition, curReadPosition, curCh)
			p.curToken = curToken
			stmt := p.parseForLoopStatement()
			return []ast.Statement{stmt}
		}

		// 保存变量名
		varName := p.curToken.Literal
		p.nextToken() // 跳过变量名

		// 检查是in还是of关键字
		if p.curTokenIs(lexer.IN) {
			// 这是一个for...in循环，解析它
			stmt := p.parseForInLoopStatement(varName, hasDeclaration)
			return []ast.Statement{stmt}
		} else if p.curTokenIs(lexer.OF) {
			// 这是一个for...of循环，解析它
			stmt := p.parseForOfLoopStatement(varName, hasDeclaration)
			return []ast.Statement{stmt}
		} else {
			// 回退并解析为普通for循环
			p.l.SetPosition(curPosition, curReadPosition, curCh)
			p.curToken = curToken
			stmt := p.parseForLoopStatement()
			return []ast.Statement{stmt}
		}
	case lexer.WHILE:
		stmt := p.parseWhileLoopStatement()
		return []ast.Statement{stmt}
	case lexer.BREAK:
		stmt := p.parseBreakStatement()
		return []ast.Statement{stmt}
	case lexer.CONTINUE:
		stmt := p.parseContinueStatement()
		return []ast.Statement{stmt}
	case lexer.CLASS:
		stmt := p.parseClassDeclaration()
		return []ast.Statement{stmt}
	case lexer.TRY:
		stmt := p.parseTryStatement()
		return []ast.Statement{stmt}
	case lexer.THROW:
		stmt := p.parseThrowStatement()
		return []ast.Statement{stmt}
	case lexer.SWITCH:
		stmt := p.parseSwitchStatement()
		if stmt != nil {
			return []ast.Statement{stmt}
		}
		return nil
	default:
		stmt := p.parseExpressionStatement()
		return []ast.Statement{stmt}
	}
}

// parseLetStatement 解析let语句
func (p *Parser) parseLetStatement() []*ast.LetStatement {
	var statements []*ast.LetStatement
	initialToken := p.curToken // 保存let关键字token

	for {
		stmt := &ast.LetStatement{Token: initialToken}

		if !p.expectPeek(lexer.IDENT) {
			return nil
		}

		stmt.Name = &ast.Identifier{
			Token: p.curToken,
			Value: p.curToken.Literal,
		}

		// 检查是否有赋值操作
		if p.peekTokenIs(lexer.ASSIGN) {
			p.nextToken() // 跳过 =
			p.nextToken() // 移动到值表达式
			stmt.Value = p.parseExpression(LOWEST)
		} else {
			// 无赋值，设置为undefined
			stmt.Value = &ast.UndefinedLiteral{
				Token: lexer.Token{Type: lexer.UNDEFINED, Literal: "undefined"},
			}
		}

		statements = append(statements, stmt)

		// 如果下一个token是逗号，继续解析下一个变量
		if p.peekTokenIs(lexer.COMMA) {
			p.nextToken() // 跳过逗号
			continue
		}

		// 否则结束解析
		break
	}

	// 处理可能的分号
	if p.peekTokenIs(lexer.SEMICOLON) {
		p.nextToken()
	}

	return statements
}

// parseVarStatement 解析var语句
func (p *Parser) parseVarStatement() []*ast.VarStatement {
	var statements []*ast.VarStatement
	initialToken := p.curToken // 保存var关键字token

	for {
		stmt := &ast.VarStatement{Token: initialToken}

		if !p.expectPeek(lexer.IDENT) {
			return nil
		}

		stmt.Name = &ast.Identifier{
			Token: p.curToken,
			Value: p.curToken.Literal,
		}

		// 检查是否有赋值操作
		if p.peekTokenIs(lexer.ASSIGN) {
			p.nextToken() // 跳过 =
			p.nextToken() // 移动到值表达式
			stmt.Value = p.parseExpression(LOWEST)
		} else {
			// 无赋值，设置为undefined
			stmt.Value = &ast.UndefinedLiteral{
				Token: lexer.Token{Type: lexer.UNDEFINED, Literal: "undefined"},
			}
		}

		statements = append(statements, stmt)

		// 如果下一个token是逗号，继续解析下一个变量
		if p.peekTokenIs(lexer.COMMA) {
			p.nextToken() // 跳过逗号
			continue
		}

		// 否则结束解析
		break
	}

	// 处理可能的分号
	if p.peekTokenIs(lexer.SEMICOLON) {
		p.nextToken()
	}

	return statements
}

// parseConstStatement 解析const语句
func (p *Parser) parseConstStatement() []*ast.ConstStatement {
	var statements []*ast.ConstStatement
	initialToken := p.curToken // 保存const关键字token

	for {
		stmt := &ast.ConstStatement{Token: initialToken}

		if !p.expectPeek(lexer.IDENT) {
			return nil
		}

		stmt.Name = &ast.Identifier{
			Token: p.curToken,
			Value: p.curToken.Literal,
		}

		// const声明必须有初始值
		if !p.expectPeek(lexer.ASSIGN) {
			p.addError("const声明必须有初始值")
			return nil
		}

		p.nextToken()
		stmt.Value = p.parseExpression(LOWEST)

		statements = append(statements, stmt)

		// 如果下一个token是逗号，继续解析下一个变量
		if p.peekTokenIs(lexer.COMMA) {
			p.nextToken() // 跳过逗号
			continue
		}

		// 否则结束解析
		break
	}

	// 处理可能的分号
	if p.peekTokenIs(lexer.SEMICOLON) {
		p.nextToken()
	}

	return statements
}

// parseReturnStatement 解析return语句
func (p *Parser) parseReturnStatement() *ast.ReturnStatement {
	stmt := &ast.ReturnStatement{Token: p.curToken}

	p.nextToken()

	// 如果return后面是分号或右大括号，表示无值返回
	if p.curTokenIs(lexer.SEMICOLON) || p.curTokenIs(lexer.RBRACE) {
		if p.curTokenIs(lexer.SEMICOLON) {
			p.nextToken() // 跳过分号
		}
		return stmt
	}

	stmt.ReturnValue = p.parseExpression(LOWEST)

	if p.peekTokenIs(lexer.SEMICOLON) {
		p.nextToken()
	}

	return stmt
}

// parseExpressionStatement 解析表达式语句
func (p *Parser) parseExpressionStatement() *ast.ExpressionStatement {
	stmt := &ast.ExpressionStatement{Token: p.curToken}
	stmt.Expression = p.parseExpression(LOWEST)

	if p.peekTokenIs(lexer.SEMICOLON) {
		p.nextToken()
	}

	return stmt
}

// parseBlockStatement 解析块语句
func (p *Parser) parseBlockStatement() *ast.BlockStatement {
	block := &ast.BlockStatement{Token: p.curToken}
	block.Statements = []ast.Statement{}

	p.nextToken()

	for !p.curTokenIs(lexer.RBRACE) && !p.curTokenIs(lexer.EOF) {
		stmt := p.parseStatement()
		if stmt != nil {
			block.Statements = append(block.Statements, stmt...)
		}
		p.nextToken()
	}

	if !p.curTokenIs(lexer.RBRACE) {
		p.addError("块语句没有以 } 结束")
		return nil
	}

	return block
}

// parseExpression 解析表达式
func (p *Parser) parseExpression(precedence int) ast.Expression {
	prefix := p.prefixParseFns[p.curToken.Type]
	if prefix == nil {
		p.noPrefixParseFnError(p.curToken.Type)
		return nil
	}
	leftExp := prefix()

	for !p.peekTokenIs(lexer.SEMICOLON) && precedence < p.peekPrecedence() {
		infix := p.infixParseFns[p.peekToken.Type]
		if infix == nil {
			return leftExp
		}

		p.nextToken()

		leftExp = infix(leftExp)
	}

	return leftExp
}

// parseIdentifier 解析标识符
func (p *Parser) parseIdentifier() ast.Expression {
	ident := &ast.Identifier{
		Token: p.curToken,
		Value: p.curToken.Literal,
	}

	// 特殊处理: 检查下一个token是否是箭头，如果是，则解析为单参数箭头函数
	if p.peekTokenIs(lexer.ARROW) {
		// 消费 => 符号
		p.nextToken()

		// 创建箭头函数
		arrowFunc := &ast.ArrowFunctionLiteral{
			Token:      p.curToken,
			Parameters: []*ast.Identifier{ident},
		}

		// 消费表达式体或块语句体
		p.nextToken()

		// 检查是否是块语句体
		if p.curTokenIs(lexer.LBRACE) {
			arrowFunc.Body = p.parseBlockStatement()
		} else {
			arrowFunc.Body = p.parseExpression(LOWEST)
		}

		return arrowFunc
	}

	return ident
}

// parseIntegerLiteral 解析整数字面量
func (p *Parser) parseIntegerLiteral() ast.Expression {
	lit := &ast.IntegerLiteral{Token: p.curToken}

	value, err := strconv.ParseInt(p.curToken.Literal, 0, 64)
	if err != nil {
		p.addError("无法将 %q 解析为整数", p.curToken.Literal)
		return nil
	}

	lit.Value = value
	return lit
}

// parseFloatLiteral 解析浮点数字面量
func (p *Parser) parseFloatLiteral() ast.Expression {
	lit := &ast.FloatLiteral{Token: p.curToken}

	value, err := strconv.ParseFloat(p.curToken.Literal, 64)
	if err != nil {
		p.addError("无法将 %q 解析为浮点数", p.curToken.Literal)
		return nil
	}

	lit.Value = value
	return lit
}

// parseStringLiteral 解析字符串字面量
func (p *Parser) parseStringLiteral() ast.Expression {
	lit := &ast.StringLiteral{
		Token: p.curToken,
		Value: p.curToken.Literal,
	}

	// 检测未闭合的字符串
	if p.curToken.Type == lexer.STRING && p.curToken.Literal == "" {
		p.addFriendlyError("未闭合的字符串", p.curToken)
	}

	return lit
}

// parseTemplateLiteral 解析模板字符串
func (p *Parser) parseTemplateLiteral() ast.Expression {
	template := &ast.TemplateLiteral{
		Token:       p.curToken,
		Expressions: []ast.Expression{},
		Quasis:      []string{},
	}

	// 对于现阶段简化处理，我们只支持模板字符串作为整体
	template.Quasis = append(template.Quasis, p.curToken.Literal)

	return template
}

// parseBooleanLiteral 解析布尔字面量
func (p *Parser) parseBooleanLiteral() ast.Expression {
	return &ast.BooleanLiteral{
		Token: p.curToken,
		Value: p.curTokenIs(lexer.TRUE),
	}
}

// parseNullLiteral 解析null字面量
func (p *Parser) parseNullLiteral() ast.Expression {
	return &ast.NullLiteral{Token: p.curToken}
}

// parseUndefinedLiteral 解析undefined字面量
func (p *Parser) parseUndefinedLiteral() ast.Expression {
	return &ast.UndefinedLiteral{Token: p.curToken}
}

// parsePrefixExpression 解析前缀表达式
func (p *Parser) parsePrefixExpression() ast.Expression {
	expression := &ast.PrefixExpression{
		Token:    p.curToken,
		Operator: p.curToken.Literal,
	}

	p.nextToken()

	expression.Right = p.parseExpression(PREFIX)

	return expression
}

// parseInfixExpression 解析中缀表达式
func (p *Parser) parseInfixExpression(left ast.Expression) ast.Expression {
	expression := &ast.InfixExpression{
		Token:    p.curToken,
		Operator: p.curToken.Literal,
		Left:     left,
	}

	precedence := p.curPrecedence()
	p.nextToken()
	expression.Right = p.parseExpression(precedence)

	return expression
}

// parseAssignExpression 解析赋值表达式
func (p *Parser) parseAssignExpression(left ast.Expression) ast.Expression {
	expression := &ast.AssignExpression{
		Token: p.curToken,
		Left:  left,
	}

	p.nextToken()
	expression.Value = p.parseExpression(LOWEST)

	return expression
}

// parsePostfixExpression 解析后缀表达式 (i++, i--)
func (p *Parser) parsePostfixExpression(left ast.Expression) ast.Expression {
	expression := &ast.PostfixExpression{
		Token:    p.curToken,
		Left:     left,
		Operator: p.curToken.Literal,
	}

	return expression
}

// parseCompoundAssignExpression 解析复合赋值表达式 (+=, -=, *=, /=, %=)
func (p *Parser) parseCompoundAssignExpression(left ast.Expression) ast.Expression {
	expression := &ast.CompoundAssignExpression{
		Token:    p.curToken,
		Left:     left,
		Operator: p.curToken.Literal,
	}

	p.nextToken()
	expression.Value = p.parseExpression(LOWEST)

	return expression
}

// parseGroupedExpression 解析括号表达式
func (p *Parser) parseGroupedExpression() ast.Expression {
	p.nextToken()

	// 检查是否是空括号，表示无参数箭头函数
	if p.curTokenIs(lexer.RPAREN) && p.peekTokenIs(lexer.ARROW) {
		p.nextToken() // 跳过 )
		p.nextToken() // 跳过 =>
		return p.parseArrowFunctionBody([]*ast.Identifier{})
	}

	// 收集可能的参数，以便判断是箭头函数还是分组表达式
	var potentialParams []*ast.Identifier
	isSimpleParamList := true

	// 读取可能的参数列表
	for !p.curTokenIs(lexer.RPAREN) && isSimpleParamList {
		if !p.curTokenIs(lexer.IDENT) {
			isSimpleParamList = false
			break
		}

		ident := &ast.Identifier{Token: p.curToken, Value: p.curToken.Literal}
		potentialParams = append(potentialParams, ident)

		p.nextToken()

		if p.curTokenIs(lexer.COMMA) {
			p.nextToken()
		} else if !p.curTokenIs(lexer.RPAREN) {
			isSimpleParamList = false
		}
	}

	// 如果不是有效的括号结束或者不是简单的参数列表，则作为正常分组表达式处理
	if !p.curTokenIs(lexer.RPAREN) || !isSimpleParamList {
		exp := p.parseExpression(LOWEST)
		if !p.expectPeek(lexer.RPAREN) {
			return nil
		}
		return exp
	}

	// 检查下一个token是否是箭头，如果是，则解析为箭头函数
	if p.peekTokenIs(lexer.ARROW) {
		p.nextToken() // 跳过 )
		p.nextToken() // 跳过 =>
		return p.parseArrowFunctionBody(potentialParams)
	}

	// 否则就是普通的分组表达式
	p.nextToken() // 跳过 )
	exp := p.parseExpression(LOWEST)
	return exp
}

// 解析箭头函数体，可用于单参数和多参数形式
func (p *Parser) parseArrowFunctionBody(params []*ast.Identifier) ast.Expression {
	arrowFunction := &ast.ArrowFunctionLiteral{
		Token:      p.curToken,
		Parameters: params,
	}

	// 检查是否是块语句体
	if p.curTokenIs(lexer.LBRACE) {
		arrowFunction.Body = p.parseBlockStatement()
	} else {
		// 单个表达式体
		arrowFunction.Body = p.parseExpression(LOWEST)
	}

	return arrowFunction
}

// parseIfExpression 解析if表达式
func (p *Parser) parseIfExpression() ast.Expression {
	expression := &ast.IfExpression{Token: p.curToken}

	if !p.expectPeek(lexer.LPAREN) {
		return nil
	}

	p.nextToken()
	expression.Condition = p.parseExpression(LOWEST)

	if !p.expectPeek(lexer.RPAREN) {
		return nil
	}

	if !p.expectPeek(lexer.LBRACE) {
		return nil
	}

	expression.Consequence = p.parseBlockStatement()

	if p.peekTokenIs(lexer.ELSE) {
		p.nextToken()

		if !p.expectPeek(lexer.LBRACE) {
			return nil
		}

		expression.Alternative = p.parseBlockStatement()
	}

	return expression
}

// parseFunctionLiteral 解析函数字面量
func (p *Parser) parseFunctionLiteral() ast.Expression {
	lit := &ast.FunctionLiteral{Token: p.curToken}

	// 检查是否有函数名称（命名函数）
	if p.peekTokenIs(lexer.IDENT) {
		p.nextToken()
		lit.Name = p.curToken.Literal
	}

	if !p.expectPeek(lexer.LPAREN) {
		return nil
	}

	lit.Parameters = p.parseFunctionParameters()

	if !p.expectPeek(lexer.LBRACE) {
		return nil
	}

	lit.Body = p.parseBlockStatement()

	return lit
}

// parseFunctionParameters 解析函数参数
func (p *Parser) parseFunctionParameters() []*ast.Identifier {
	identifiers := []*ast.Identifier{}

	if p.peekTokenIs(lexer.RPAREN) {
		p.nextToken()
		return identifiers
	}

	p.nextToken()

	ident := &ast.Identifier{
		Token: p.curToken,
		Value: p.curToken.Literal,
	}
	identifiers = append(identifiers, ident)

	for p.peekTokenIs(lexer.COMMA) {
		p.nextToken()
		p.nextToken()
		ident := &ast.Identifier{
			Token: p.curToken,
			Value: p.curToken.Literal,
		}
		identifiers = append(identifiers, ident)
	}

	if !p.expectPeek(lexer.RPAREN) {
		return nil
	}

	return identifiers
}

// parseCallExpression 解析函数调用表达式
func (p *Parser) parseCallExpression(function ast.Expression) ast.Expression {
	exp := &ast.CallExpression{
		Token:    p.curToken,
		Function: function,
	}
	exp.Arguments = p.parseExpressionList(lexer.RPAREN)
	return exp
}

// parseArrayLiteral 解析数组字面量
func (p *Parser) parseArrayLiteral() ast.Expression {
	array := &ast.ArrayLiteral{Token: p.curToken}
	array.Elements = p.parseExpressionList(lexer.RBRACKET)
	return array
}

// parseExpressionList 解析表达式列表
func (p *Parser) parseExpressionList(end lexer.TokenType) []ast.Expression {
	list := []ast.Expression{}

	if p.peekTokenIs(end) {
		p.nextToken()
		return list
	}

	p.nextToken()
	list = append(list, p.parseExpression(LOWEST))

	for p.peekTokenIs(lexer.COMMA) {
		p.nextToken() // 消耗逗号

		// 检查是否是尾随逗号（逗号后直接是结束符号）
		if p.peekTokenIs(end) {
			break // 允许尾随逗号，直接结束循环
		}

		p.nextToken()
		list = append(list, p.parseExpression(LOWEST))
	}

	if !p.expectPeek(end) {
		return nil
	}

	return list
}

// parseIndexExpression 解析索引表达式
func (p *Parser) parseIndexExpression(left ast.Expression) ast.Expression {
	exp := &ast.IndexExpression{
		Token: p.curToken,
		Left:  left,
	}

	p.nextToken()
	exp.Index = p.parseExpression(LOWEST)

	if !p.expectPeek(lexer.RBRACKET) {
		return nil
	}

	return exp
}

// parsePropertyExpression 解析属性访问表达式
func (p *Parser) parsePropertyExpression(object ast.Expression) ast.Expression {
	exp := &ast.PropertyExpression{
		Token:  p.curToken,
		Object: object,
	}

	p.nextToken()
	exp.Property = p.parseExpression(PROPERTY)

	return exp
}

// parseObjectLiteral 解析对象字面量
func (p *Parser) parseObjectLiteral() ast.Expression {
	obj := &ast.ObjectLiteral{
		Token:    p.curToken,
		Pairs:    make(map[ast.Expression]ast.Expression),
		KeyTypes: make(map[ast.Expression]string),
	}

	if p.peekTokenIs(lexer.RBRACE) {
		p.nextToken()
		return obj
	}

	p.nextToken()

	// 解析键
	var key ast.Expression
	var keyType string

	// 处理计算属性 [expr]
	if p.curTokenIs(lexer.LBRACKET) {
		p.nextToken() // 跳过 [
		key = p.parseExpression(LOWEST)
		keyType = "computed"

		if !p.expectPeek(lexer.RBRACKET) {
			return nil
		}
	} else {
		// 普通键（字符串或标识符）
		key = p.parseExpression(LOWEST)
		keyType = "string"
	}

	// 检查冒号
	if !p.expectPeek(lexer.COLON) {
		// 如果没有冒号，给出更具体的错误提示
		p.addFriendlyError(fmt.Sprintf("对象字面量中的键值对应为冒号，但得到了 %s", p.peekToken.Type), p.curToken)
		return nil
	}

	p.nextToken()
	value := p.parseExpression(LOWEST)

	obj.Pairs[key] = value
	obj.KeyTypes[key] = keyType

	// 检查逗号或右大括号
	if !p.peekTokenIs(lexer.RBRACE) && !p.expectPeek(lexer.COMMA) {
		// 如果既不是右大括号也不是逗号，给出更具体的错误提示
		p.addFriendlyError(fmt.Sprintf("对象字面量中的键值对后应为逗号或右大括号，但得到了 %s", p.peekToken.Type), p.curToken)
		return nil
	}

	for p.peekTokenIs(lexer.COMMA) {
		p.nextToken() // 消耗逗号

		// 检查是否是尾随逗号（逗号后直接是闭花括号）
		if p.peekTokenIs(lexer.RBRACE) {
			break // 允许尾随逗号，直接结束循环
		}

		p.nextToken()

		// 解析键
		if p.curTokenIs(lexer.LBRACKET) {
			p.nextToken() // 跳过 [
			key = p.parseExpression(LOWEST)
			keyType = "computed"

			if !p.expectPeek(lexer.RBRACKET) {
				return nil
			}
		} else {
			// 普通键（字符串或标识符）
			key = p.parseExpression(LOWEST)
			keyType = "string"
		}

		if !p.expectPeek(lexer.COLON) {
			// 如果没有冒号，给出更具体的错误提示
			p.addFriendlyError(fmt.Sprintf("对象字面量中的键值对应为冒号，但得到了 %s", p.peekToken.Type), p.curToken)
			return nil
		}

		p.nextToken()
		value := p.parseExpression(LOWEST)

		obj.Pairs[key] = value
		obj.KeyTypes[key] = keyType
	}

	// 检查右大括号
	if !p.expectPeek(lexer.RBRACE) {
		// 如果没有右大括号，给出更具体的错误提示
		if p.peekTokenIs(lexer.EOF) {
			p.addFriendlyError("对象字面量未闭合，缺少右大括号", p.curToken)
		} else {
			p.addFriendlyError(fmt.Sprintf("对象字面量中的键值对后应为逗号或右大括号，但得到了 %s", p.peekToken.Type), p.curToken)
		}
		return nil
	}

	return obj
}

// curTokenIs 检查当前Token的类型
func (p *Parser) curTokenIs(t lexer.TokenType) bool {
	return p.curToken.Type == t
}

// peekTokenIs 检查下一个Token的类型
func (p *Parser) peekTokenIs(t lexer.TokenType) bool {
	return p.peekToken.Type == t
}

// expectPeek 判断下一个Token的类型是否为预期类型，如果是则前进
func (p *Parser) expectPeek(t lexer.TokenType) bool {
	if p.peekTokenIs(t) {
		p.nextToken()
		return true
	}
	p.peekError(t)
	return false
}

// peekPrecedence 获取下一个Token的优先级
func (p *Parser) peekPrecedence() int {
	if p, ok := precedences[p.peekToken.Type]; ok {
		return p
	}
	return LOWEST
}

// curPrecedence 获取当前Token的优先级
func (p *Parser) curPrecedence() int {
	if p, ok := precedences[p.curToken.Type]; ok {
		return p
	}
	return LOWEST
}

// noPrefixParseFnError 添加一个找不到前缀解析函数的错误
func (p *Parser) noPrefixParseFnError(t lexer.TokenType) {
	msg := fmt.Sprintf("找不到用于解析 %s 的前缀解析函数", t)
	p.addFriendlyError(msg, p.curToken)
}

// parseFunctionStatement 解析函数声明语句
func (p *Parser) parseFunctionStatement() ast.Statement {
	stmt := &ast.FunctionStatement{Token: p.curToken}

	// 必须有函数名
	if !p.expectPeek(lexer.IDENT) {
		return nil
	}

	stmt.Name = &ast.Identifier{
		Token: p.curToken,
		Value: p.curToken.Literal,
	}

	if !p.expectPeek(lexer.LPAREN) {
		return nil
	}

	stmt.Parameters = p.parseFunctionParameters()

	if !p.expectPeek(lexer.LBRACE) {
		return nil
	}

	stmt.Body = p.parseBlockStatement()

	return stmt
}

// parseConditionalExpression 解析三元条件表达式
func (p *Parser) parseConditionalExpression(condition ast.Expression) ast.Expression {
	expression := &ast.ConditionalExpression{
		Token:     p.curToken,
		Condition: condition,
	}

	precedence := p.curPrecedence()
	p.nextToken()
	expression.Consequence = p.parseExpression(precedence)

	if !p.expectPeek(lexer.COLON) {
		return nil
	}

	p.nextToken()
	expression.Alternative = p.parseExpression(precedence)

	return expression
}

// parseForLoopStatement 解析for循环语句
func (p *Parser) parseForLoopStatement() *ast.ForLoopStatement {
	stmt := &ast.ForLoopStatement{Token: p.curToken}

	if !p.expectPeek(lexer.LPAREN) {
		return nil
	}

	// 解析初始化语句
	if !p.peekTokenIs(lexer.SEMICOLON) {
		p.nextToken()

		if p.curTokenIs(lexer.LET) {
			statements := p.parseLetStatement()
			if len(statements) > 0 {
				stmt.Init = statements[0]
			}
		} else if p.curTokenIs(lexer.VAR) {
			statements := p.parseVarStatement()
			if len(statements) > 0 {
				stmt.Init = statements[0]
			}
		} else if p.curTokenIs(lexer.CONST) {
			statements := p.parseConstStatement()
			if len(statements) > 0 {
				stmt.Init = statements[0]
			}
		} else {
			stmt.Init = p.parseExpressionStatement()
		}

		// 确保我们位于分号之后
		if !p.curTokenIs(lexer.SEMICOLON) {
			return nil
		}
	} else {
		p.nextToken() // 跳过起始位置的分号
	}

	// 解析条件表达式
	if !p.peekTokenIs(lexer.SEMICOLON) {
		p.nextToken()
		stmt.Condition = p.parseExpression(LOWEST)

		if !p.expectPeek(lexer.SEMICOLON) {
			return nil
		}
	} else {
		p.nextToken() // 跳过第二个分号
	}

	// 解析更新表达式
	if !p.peekTokenIs(lexer.RPAREN) {
		p.nextToken()
		stmt.Update = p.parseExpression(LOWEST)

		if !p.expectPeek(lexer.RPAREN) {
			return nil
		}
	} else {
		p.nextToken() // 跳过右括号
	}

	// 解析循环体
	if !p.expectPeek(lexer.LBRACE) {
		return nil
	}

	stmt.Body = p.parseBlockStatement()

	return stmt
}

// parseWhileLoopStatement 解析while循环语句
func (p *Parser) parseWhileLoopStatement() *ast.WhileLoopStatement {
	stmt := &ast.WhileLoopStatement{Token: p.curToken}

	if !p.expectPeek(lexer.LPAREN) {
		return nil
	}

	p.nextToken() // 跳过 (

	// 解析条件表达式
	stmt.Condition = p.parseExpression(LOWEST)

	if !p.expectPeek(lexer.RPAREN) {
		return nil
	}

	if !p.expectPeek(lexer.LBRACE) {
		return nil
	}

	stmt.Body = p.parseBlockStatement()

	return stmt
}

// parseBreakStatement 解析break语句
func (p *Parser) parseBreakStatement() *ast.BreakStatement {
	stmt := &ast.BreakStatement{Token: p.curToken}

	// 跳过分号（如果有）
	if p.peekTokenIs(lexer.SEMICOLON) {
		p.nextToken()
	}

	return stmt
}

// parseContinueStatement 解析continue语句
func (p *Parser) parseContinueStatement() *ast.ContinueStatement {
	stmt := &ast.ContinueStatement{Token: p.curToken}

	// 跳过分号（如果有）
	if p.peekTokenIs(lexer.SEMICOLON) {
		p.nextToken()
	}

	return stmt
}

// parseClassDeclaration 解析类声明
func (p *Parser) parseClassDeclaration() *ast.ClassDeclaration {
	decl := &ast.ClassDeclaration{Token: p.curToken}

	// 解析类名
	if !p.expectPeek(lexer.IDENT) {
		return nil
	}
	decl.Name = &ast.Identifier{Token: p.curToken, Value: p.curToken.Literal}

	// 检查是否有extends关键字
	if p.peekTokenIs(lexer.EXTENDS) {
		p.nextToken() // 跳过extends关键字

		if !p.expectPeek(lexer.IDENT) {
			return nil
		}
		decl.SuperClass = &ast.Identifier{Token: p.curToken, Value: p.curToken.Literal}
	}

	// 解析类体
	if !p.expectPeek(lexer.LBRACE) {
		return nil
	}

	decl.Body = p.parseClassBody()

	return decl
}

// parseClassExpression 解析类表达式
func (p *Parser) parseClassExpression() ast.Expression {
	expr := &ast.ClassExpression{Token: p.curToken}

	// 检查是否有类名（可选）
	if p.peekTokenIs(lexer.IDENT) {
		p.nextToken()
		expr.Name = &ast.Identifier{Token: p.curToken, Value: p.curToken.Literal}
	}

	// 检查是否有extends关键字
	if p.peekTokenIs(lexer.EXTENDS) {
		p.nextToken() // 跳过extends关键字

		if !p.expectPeek(lexer.IDENT) {
			return nil
		}
		expr.SuperClass = &ast.Identifier{Token: p.curToken, Value: p.curToken.Literal}
	}

	// 解析类体
	if !p.expectPeek(lexer.LBRACE) {
		return nil
	}

	expr.Body = p.parseClassBody()

	return expr
}

// parseClassBody 解析类体
func (p *Parser) parseClassBody() *ast.ClassBody {
	body := &ast.ClassBody{Token: p.curToken}
	body.Methods = []*ast.MethodDefinition{}
	body.Properties = []*ast.PropertyDefinition{}

	p.nextToken()

	for !p.curTokenIs(lexer.RBRACE) && !p.curTokenIs(lexer.EOF) {
		// 检查是否是静态成员
		isStatic := false
		if p.curTokenIs(lexer.STATIC) {
			isStatic = true
			p.nextToken()
		}

		if p.curTokenIs(lexer.IDENT) || p.curTokenIs(lexer.CONSTRUCTOR) {
			// 识别是方法还是属性
			if p.peekTokenIs(lexer.LPAREN) {
				// 这是一个方法定义
				method := p.parseMethodDefinition()
				if method != nil {
					method.IsStatic = isStatic
					body.Methods = append(body.Methods, method)
				}
			} else if p.peekTokenIs(lexer.ASSIGN) || p.peekTokenIs(lexer.SEMICOLON) {
				// 这是一个属性定义
				property := p.parsePropertyDefinition()
				if property != nil {
					property.IsStatic = isStatic
					body.Properties = append(body.Properties, property)
				}
			}
		}

		// 可选的分号
		if p.peekTokenIs(lexer.SEMICOLON) {
			p.nextToken()
		}

		p.nextToken()
	}

	return body
}

// parseMethodDefinition 解析方法定义
func (p *Parser) parseMethodDefinition() *ast.MethodDefinition {
	method := &ast.MethodDefinition{Token: p.curToken}
	method.Name = &ast.Identifier{Token: p.curToken, Value: p.curToken.Literal}

	// 解析参数
	if !p.expectPeek(lexer.LPAREN) {
		return nil
	}

	method.Params = p.parseFunctionParameters()

	// 解析方法体
	if !p.expectPeek(lexer.LBRACE) {
		return nil
	}

	// 解析块语句
	block := &ast.BlockStatement{Token: p.curToken}
	block.Statements = []ast.Statement{}

	p.nextToken()

	for !p.curTokenIs(lexer.RBRACE) && !p.curTokenIs(lexer.EOF) {
		stmt := p.parseStatement()
		if stmt != nil {
			block.Statements = append(block.Statements, stmt...)
		}
		p.nextToken()
	}

	method.Body = block

	return method
}

// parsePropertyDefinition 解析属性定义
func (p *Parser) parsePropertyDefinition() *ast.PropertyDefinition {
	property := &ast.PropertyDefinition{Token: p.curToken}
	property.Name = &ast.Identifier{Token: p.curToken, Value: p.curToken.Literal}

	// 检查是否有初始值
	if p.peekTokenIs(lexer.ASSIGN) {
		p.nextToken() // 跳过=
		p.nextToken()
		property.Value = p.parseExpression(LOWEST)
	}

	return property
}

// parseNewExpression 解析new表达式
func (p *Parser) parseNewExpression() ast.Expression {
	expression := &ast.NewExpression{Token: p.curToken}

	// 跳过new关键字
	p.nextToken()

	// 获取当前优先级，确保不会错误解析函数调用
	precedence := CALL

	// 解析构造函数（类名）
	expression.Constructor = p.parseExpression(precedence)

	// 解析构造函数调用参数
	if p.peekTokenIs(lexer.LPAREN) {
		p.nextToken()
		expression.Arguments = p.parseExpressionList(lexer.RPAREN)
	} else {
		expression.Arguments = []ast.Expression{}
	}

	return expression
}

// parseThisExpression 解析this表达式
func (p *Parser) parseThisExpression() ast.Expression {
	return &ast.ThisExpression{Token: p.curToken}
}

// parseTryStatement 解析try语句
func (p *Parser) parseTryStatement() *ast.TryStatement {
	stmt := &ast.TryStatement{Token: p.curToken}

	// 解析try块
	if !p.expectPeek(lexer.LBRACE) {
		return nil
	}

	stmt.Body = p.parseBlockStatement()

	// 解析catch块（可选）
	if p.peekTokenIs(lexer.CATCH) {
		p.nextToken()
		catchClause := &ast.CatchClause{Token: p.curToken}

		// 解析参数（可选）
		if p.peekTokenIs(lexer.LPAREN) {
			p.nextToken()

			if !p.expectPeek(lexer.IDENT) {
				return nil
			}

			catchClause.Parameter = &ast.Identifier{
				Token: p.curToken,
				Value: p.curToken.Literal,
			}

			if !p.expectPeek(lexer.RPAREN) {
				return nil
			}
		}

		// 解析catch块体
		if !p.expectPeek(lexer.LBRACE) {
			return nil
		}

		catchClause.Body = p.parseBlockStatement()
		stmt.Catch = catchClause
	}

	// 解析finally块（可选）
	if p.peekTokenIs(lexer.FINALLY) {
		p.nextToken()
		finallyClause := &ast.FinallyClause{Token: p.curToken}

		// 解析finally块体
		if !p.expectPeek(lexer.LBRACE) {
			return nil
		}

		finallyClause.Body = p.parseBlockStatement()
		stmt.Finally = finallyClause
	}

	// 确保至少有一个catch或finally块
	if stmt.Catch == nil && stmt.Finally == nil {
		p.addError("try语句必须至少有一个catch或finally块")
		return nil
	}

	return stmt
}

// parseThrowStatement 解析throw语句
func (p *Parser) parseThrowStatement() *ast.ThrowStatement {
	stmt := &ast.ThrowStatement{Token: p.curToken}

	p.nextToken()
	stmt.Value = p.parseExpression(LOWEST)

	if p.peekTokenIs(lexer.SEMICOLON) {
		p.nextToken()
	}

	return stmt
}

// 修改单参数箭头函数的解析函数，使用新的通用箭头函数体解析
func (p *Parser) parseArrowFunctionWithSingleParam(left ast.Expression) ast.Expression {
	// 确保左侧是标识符
	ident, ok := left.(*ast.Identifier)
	if !ok {
		p.addError("箭头函数左侧必须是标识符")
		return nil
	}

	// 使用通用的箭头函数体解析
	p.nextToken()

	// 创建箭头函数
	arrowFunction := &ast.ArrowFunctionLiteral{
		Token:      p.curToken,
		Parameters: []*ast.Identifier{ident},
	}

	// 检查是否是块语句体
	if p.peekTokenIs(lexer.LBRACE) {
		p.nextToken() // 移动到 {
		arrowFunction.Body = p.parseBlockStatement()
	} else {
		// 单个表达式体
		p.nextToken() // 移动到表达式开始
		arrowFunction.Body = p.parseExpression(LOWEST)
	}

	return arrowFunction
}

// 添加对直接箭头符号的处理
func (p *Parser) parseArrowWithNoParam() ast.Expression {
	token := p.curToken

	// 跳过 => 符号
	p.nextToken()

	// 创建箭头函数对象
	arrowFunction := &ast.ArrowFunctionLiteral{
		Token:      token,
		Parameters: []*ast.Identifier{},
	}

	// 检查是否是块语句体
	if p.curTokenIs(lexer.LBRACE) {
		arrowFunction.Body = p.parseBlockStatement()
	} else {
		// 单个表达式体
		arrowFunction.Body = p.parseExpression(LOWEST)
	}

	return arrowFunction
}

// parseForInLoopStatement 解析for...in循环语句
func (p *Parser) parseForInLoopStatement(varName string, hasDeclaration bool) *ast.ForInLoopStatement {
	stmt := &ast.ForInLoopStatement{
		Token:          p.curToken,
		VarName:        varName,
		HasDeclaration: hasDeclaration,
	}

	p.nextToken() // 跳过in关键字

	// 解析对象表达式
	stmt.Object = p.parseExpression(LOWEST)

	if !p.expectPeek(lexer.RPAREN) {
		return nil
	}

	if !p.expectPeek(lexer.LBRACE) {
		return nil
	}

	stmt.Body = p.parseBlockStatement()

	return stmt
}

// parseForOfLoopStatement 解析for...of循环语句
func (p *Parser) parseForOfLoopStatement(varName string, hasDeclaration bool) *ast.ForOfLoopStatement {
	stmt := &ast.ForOfLoopStatement{
		Token:          p.curToken,
		VarName:        varName,
		HasDeclaration: hasDeclaration,
	}

	p.nextToken() // 跳过of关键字

	// 解析可迭代对象表达式
	stmt.Iterable = p.parseExpression(LOWEST)

	if !p.expectPeek(lexer.RPAREN) {
		return nil
	}

	if !p.expectPeek(lexer.LBRACE) {
		return nil
	}

	stmt.Body = p.parseBlockStatement()

	return stmt
}

// 添加解析static关键字的函数
func (p *Parser) parseStaticKeyword() ast.Expression {
	// static只能在类定义中使用，单独使用无意义，返回错误
	p.addError("static关键字只能在类定义内部使用")
	return nil
}

// 添加解析super关键字的函数
func (p *Parser) parseSuperExpression() ast.Expression {
	superExpr := &ast.SuperExpression{Token: p.curToken}

	// 检查是否有点表达式或调用表达式
	if p.peekTokenIs(lexer.DOT) || p.peekTokenIs(lexer.LPAREN) {
		return superExpr
	}

	p.addError("super关键字必须跟随.属性名或者函数调用")
	return nil
}

// 添加解析分号的函数
func (p *Parser) parseSemicolonExpression() ast.Expression {
	// 分号本身不是表达式，但我们暂时返回一个空表达式
	return &ast.EmptyExpression{Token: p.curToken}
}

// parseSwitchStatement 解析switch语句
func (p *Parser) parseSwitchStatement() *ast.SwitchStatement {
	stmt := &ast.SwitchStatement{
		Token: p.curToken,
		Cases: []*ast.SwitchCase{},
	}

	// 解析switch后面的表达式
	if !p.expectPeek(lexer.LPAREN) {
		return nil
	}

	p.nextToken() // 跳过左括号
	stmt.Value = p.parseExpression(LOWEST)

	if !p.expectPeek(lexer.RPAREN) {
		return nil
	}

	// 解析case块
	if !p.expectPeek(lexer.LBRACE) {
		return nil
	}

	p.nextToken() // 跳过左大括号

	// 解析case子句
	for !p.curTokenIs(lexer.RBRACE) && !p.curTokenIs(lexer.EOF) {
		if p.curTokenIs(lexer.CASE) {
			caseStmt := p.parseSwitchCase()
			if caseStmt != nil {
				stmt.Cases = append(stmt.Cases, caseStmt)
			}
		} else if p.curTokenIs(lexer.DEFAULT) {
			defaultCase := p.parseDefaultCase()
			if defaultCase != nil {
				stmt.Default = defaultCase
			}
		} else {
			p.addError("在switch语句中期望case或default，得到了 %s", p.curToken.Type)
			return nil
		}
	}

	// 确保有右大括号
	if !p.curTokenIs(lexer.RBRACE) {
		p.addError("switch语句没有以 } 结束")
		return nil
	}

	return stmt
}

// parseSwitchCase 解析case子句
func (p *Parser) parseSwitchCase() *ast.SwitchCase {
	caseStmt := &ast.SwitchCase{
		Token:     p.curToken,
		IsDefault: false,
	}

	p.nextToken() // 跳过case关键字
	caseStmt.Condition = p.parseExpression(LOWEST)

	if !p.expectPeek(lexer.COLON) {
		return nil
	}

	p.nextToken() // 跳过冒号

	// 解析case子句体
	caseStmt.Consequence = &ast.BlockStatement{
		Token:      p.curToken,
		Statements: []ast.Statement{},
	}

	// 读取语句，直到下一个case, default或}
	for !p.curTokenIs(lexer.CASE) && !p.curTokenIs(lexer.DEFAULT) &&
		!p.curTokenIs(lexer.RBRACE) && !p.curTokenIs(lexer.EOF) {
		stmt := p.parseStatement()
		if stmt != nil {
			caseStmt.Consequence.Statements = append(caseStmt.Consequence.Statements, stmt...)
		}
		p.nextToken()
	}

	return caseStmt
}

// parseDefaultCase 解析default子句
func (p *Parser) parseDefaultCase() *ast.SwitchCase {
	caseStmt := &ast.SwitchCase{
		Token:     p.curToken,
		IsDefault: true,
	}

	if !p.expectPeek(lexer.COLON) {
		return nil
	}

	p.nextToken() // 跳过冒号

	// 解析default子句体
	caseStmt.Consequence = &ast.BlockStatement{
		Token:      p.curToken,
		Statements: []ast.Statement{},
	}

	// 读取语句，直到下一个case或}
	for !p.curTokenIs(lexer.CASE) && !p.curTokenIs(lexer.RBRACE) && !p.curTokenIs(lexer.EOF) {
		stmt := p.parseStatement()
		if stmt != nil {
			caseStmt.Consequence.Statements = append(caseStmt.Consequence.Statements, stmt...)
		}
		p.nextToken()
	}

	return caseStmt
}

// addError 添加解析错误
func (p *Parser) addError(format string, args ...interface{}) {
	msg := fmt.Sprintf(format, args...)
	p.errors = append(p.errors, msg)

	// 同时添加到errorInfos数组，使用当前token的位置信息
	info := ErrorInfo{
		Message:  msg,
		Line:     p.curToken.Line,
		Column:   p.curToken.Column,
		CodeLine: p.l.GetSourceLine(p.curToken.Line),
	}
	p.errorInfos = append(p.errorInfos, info)
}

// ErrorInfo 存储错误信息和位置
type ErrorInfo struct {
	Message  string
	Line     int
	Column   int
	CodeLine string
}

// addFriendlyError 添加带有位置信息的友好错误消息
func (p *Parser) addFriendlyError(msg string, tok lexer.Token) {
	// 检查是否已经有相同位置的错误，避免重复
	for _, errInfo := range p.errorInfos {
		if errInfo.Line == tok.Line && errInfo.Column == tok.Column {
			// 已经有相同位置的错误，不再添加
			return
		}
	}

	// 获取源代码行
	codeLine := p.l.GetSourceLine(tok.Line)

	// 创建错误信息
	info := ErrorInfo{
		Message:  fmt.Sprintf("语法错误: 在第%d行第%d列, %s", tok.Line, tok.Column, msg),
		Line:     tok.Line,
		Column:   tok.Column,
		CodeLine: codeLine,
	}
	p.errorInfos = append(p.errorInfos, info)
	p.errors = append(p.errors, info.Message)
}

// ErrorsInfo 返回带有位置信息的错误
func (p *Parser) ErrorsInfo() []ErrorInfo {
	return p.errorInfos
}
